package vip.bblog;

import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class BblogEsCenterApplication {
/*

    @Autowired
    private LogRecordRepository logRecordRepository;

    @Autowired
    private ElasticsearchTemplate elasticsearchTemplate;

    @Autowired
    private BlogArticleService blogArticleService;

    @Test
    public void contextLoads() {
        System.out.println("context loaded");
    }

    @Test
    public void templateIndex() {
        List<BlogArticle> articleList = blogArticleService.list();
        BlogArticle article = articleList.get(0);
        IndexQuery indexQuery = new IndexQueryBuilder()
                .withIndexName("bblog_article")
                .withType("_doc")
                .withId(article.getId())
                .withObject(article)
                .build();
        String index = elasticsearchTemplate.index(indexQuery);
        System.out.println(index);
        //templateBulkIndex();
    }

    @Test
    public void templateBulkIndex() {
        List<IndexQuery> bulkDevIndexQuery = new ArrayList<>(2000);
        for (int i = 1; i <= 2000; i++) {
            LogRecord logRecord = new LogRecord();
            logRecord.setId(i);
            logRecord.setUserId(UUIDUtils.getUUID());
            logRecord.setLastTime(new Date());
            if (i <= 666) {
                logRecord.setUserName("张三");
            } else if (i <= 1299) {
                logRecord.setUserName("王五");
            } else if (i < 1699) {
                logRecord.setUserName("张五");
            } else {
                logRecord.setUserName("三王");
            }
            IndexQuery indexQuery = new IndexQueryBuilder()
                    .withIndexName("logging")
                    .withType("dev")
                    .withId(logRecord.getId().toString())
                    .withObject(logRecord)
                    .build();
            bulkDevIndexQuery.add(indexQuery);
        }
        elasticsearchTemplate.bulkIndex(bulkDevIndexQuery);
    }

    @Test
    public void templateDelete() {
        //第一种删除具体的一条记录
        elasticsearchTemplate.delete("logging", "dev", "0");

        //第二种删除indexName/type/下的所有
        */
/*DeleteQuery deleteQuery = new DeleteQuery();
        deleteQuery.setIndex("logging");
        deleteQuery.setType("test");
        elasticsearchTemplate.delete(deleteQuery);*//*


        //第三种删除indexName/下的所有
        //elasticsearchTemplate.deleteIndex("logging");

        //第四种删除查询出来的所有
        */
/*deleteQuery = new DeleteQuery();
        deleteQuery.setQuery(QueryBuilders.matchQuery("id", "100"));
        elasticsearchTemplate.delete(deleteQuery);*//*

    }

    @Test
    public void templateUpdate() {
        //更新也可以通过重建索引的方式，会自动覆盖
        LogRecord logRecord = new LogRecord();
        logRecord.setId(0);
        logRecord.setUserId(UUIDUtils.getUUID());
        logRecord.setUserName("王五");
        logRecord.setLastTime(new Date());
        IndexRequest indexRequest = new IndexRequest();
        //可以点进去看源码，更新传入参数必须是偶数个
        indexRequest.source("userId", logRecord.getUserId(), "userName", logRecord.getUserName());

        UpdateQuery updateQuery = new UpdateQueryBuilder().withId(logRecord.getId().toString())
                .withClass(LogRecord.class).withIndexRequest(indexRequest).build();

        UpdateResponse update = elasticsearchTemplate.update(updateQuery);
        System.out.println(JSON.toJSONString(update));
    }

    */
/**
 * 匹配所有文档的查询。
 * matchAllQuery()
 * 为提供的字段名和文本创建类型为“BOOLEAN”的匹配查询。(解释过来就是单个匹配，可以模糊匹配)
 * matchQuery(String name, Object text) //name 字段值 ，text 查询文本（不支持通配符）
 * 为提供的字段名和文本创建一个通用查询。
 * commonTermsQuery(String name, Object text)
 * 为提供的字段名和文本创建类型为“BOOLEAN”的匹配查询。
 * multiMatchQuery(Object text, String... fieldNames)
 * 为提供的字段名和文本创建一个文本查询，并输入“短句”。
 * matchPhraseQuery(String name, Object text)
 * 为提供的字段名和文本创建一个与类型“PHRASE_PREFIX”匹配的查询。
 * matchPhrasePrefixQuery(String name, Object text)
 * 匹配包含术语的文档的查询。
 * termQuery(String name, Object value)
 * 使用模糊查询匹配文档的查询
 * fuzzyQuery(String name, Object value)
 * 与包含指定前缀的术语的文档相匹配的查询。
 * prefixQuery(String name, String prefix)
 * 在一定范围内匹配文档的查询。
 * rangeQuery(String name)
 * 实现通配符搜索查询。支持的通配符是*，它匹配任何字符序列(包括空字符)，而?它匹配任何单个字符。注意，这个查询可能很慢，因为它需要遍历许多项。为了防止异常缓慢的通配符查询，通配符项不应该以一个通配符*或?开头。
 * <p>
 * wildcardQuery(String name, String query) //query 通配符查询字符串
 * 将包含术语的文档与指定的正则表达式匹配的查询
 * regexpQuery(String name, String regexp) //regexp的正则表达式
 * 解析查询字符串并运行它的查询。有两种模式。第一,当没有字段添加(使用QueryStringQueryBuilder.field(字符串),将运行查询一次,非前缀字段将使用QueryStringQueryBuilder.defaultField(字符串)。第二,当一个或多个字段添加(使用QueryStringQueryBuilder.field(String)),将运行提供的解析查询字段,并结合使用DisMax或普通的布尔查询(参见QueryStringQueryBuilder.useDisMax(布尔))。
 * <p>
 * queryStringQuery(String queryString)
 * 类似于query_string查询的查询，但不会为任何奇怪的字符串语法抛出异常。
 * simpleQueryStringQuery(String queryString)
 * 可以使用BoostingQuery类来有效地降级与给定查询匹配的结果。
 * boostingQuery()
 * 匹配与其他查询的布尔组合匹配的文档的查询
 * boolQuery()
 * 创建一个可用于实现MultiTermQueryBuilder的子查询的SpanQueryBuilder。
 * spanMultiTermQueryBuilder(MultiTermQueryBuilder multiTermQueryBuilder)
 * 允许定义自定义得分函数的查询。
 * functionScoreQuery(QueryBuilder queryBuilder, ScoreFunctionBuilder function)
 * 更像这样的查询，查找“like”提供的文档，例如提供的MoreLikeThisQueryBuilder.likeText(String)，它是针对查询所构造的字段进行检查的
 * <p>
 * moreLikeThisQuery(String... fields)
 * 构造一个新的非计分子查询，包含子类型和要在子文档上运行的查询。这个查询的结果是这些子文档匹配的父文档。
 * hasChildQuery(String type, QueryBuilder query)
 * 构造一个新的非评分父查询，父类型和在父文档上运行的查询。这个查询的结果是父文档匹配的子文档。
 * hasParentQuery(String type, QueryBuilder query)
 * 基于对其中任何一个项进行匹配的若干项的字段文件
 * termsQuery(String name, String... values)
 * 一个查询构建器，它允许构建给定JSON字符串或二进制数据作为输入的查询。当您希望使用Java Builder API，但仍然需要将JSON查询字符串与其他查询构建器结合时，这是非常有用的。
 * <p>
 * wrapperQuery(String source)
 *//*

    @Test
    public void templateSearch() {
        Sort sort = new Sort(Sort.Direction.DESC, "id");
        Pageable pageable = PageRequest.of(0, 10, sort);

        */
/**
 * 匹配所有
 *//*

        SearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.matchAllQuery())
                .withPageable(pageable)
                .build();
        AggregatedPage<LogRecord> matchAllQuery = elasticsearchTemplate.queryForPage(searchQuery, LogRecord.class);
        System.err.println("matchAllQuery");
        System.out.println(JSON.toJSONString(matchAllQuery));

        */
/**
 * 完全匹配
 *//*

        SearchQuery searchQuery1 = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.matchQuery("userName", "张三"))
                .withPageable(pageable)
                .build();
        AggregatedPage<LogRecord> matchQuery = elasticsearchTemplate.queryForPage(searchQuery1, LogRecord.class);
        System.err.println("matchQuery");
        System.out.println(JSON.toJSONString(matchQuery));

        */
/**
 * 短语匹配查询
 *//*

        SearchQuery searchQuery2 = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.matchPhraseQuery("userName", "张三"))
                .withPageable(pageable)
                .build();
        AggregatedPage<LogRecord> matchPhraseQuery = elasticsearchTemplate.queryForPage(searchQuery2, LogRecord.class);
        System.err.println("matchQuery");
        System.out.println(JSON.toJSONString(matchPhraseQuery));

        */
/**
 * like查询，关联性查询
 *//*

        String[] fields = {"userName"};
        String[] likeTexts = {"张三 王五"};
        MoreLikeThisQueryBuilder.Item[] likeItems = {};
        SearchQuery searchQuery3 = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.moreLikeThisQuery(fields, likeTexts, likeItems))
                .withPageable(pageable)
                .build();
        AggregatedPage<LogRecord> moreLikeThisQuery = elasticsearchTemplate.queryForPage(searchQuery3, LogRecord.class);
        System.err.println("moreLikeThisQuery");
        System.out.println(JSON.toJSONString(moreLikeThisQuery));

        */
/**
 * 组合查询
 *//*

        SearchQuery searchQuery4 = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.boolQuery()
                        .must(QueryBuilders.matchQuery("userName", "张三"))
                        .must(QueryBuilders.wildcardQuery("userName", "王五"))
                        .should(QueryBuilders.matchQuery("userName", "三王")))
                .withPageable(pageable)
                .build();
        AggregatedPage<LogRecord> boolQuery = elasticsearchTemplate.queryForPage(searchQuery4, LogRecord.class);
        System.err.println("boolQuery");
        System.out.println(JSON.toJSONString(boolQuery));

        */
/**
 * 包裹查询
 *//*

        SearchQuery searchQuery5 = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.constantScoreQuery(QueryBuilders.matchQuery("userName", "张三"))
                        .boost(2.0F))
                .withPageable(pageable)
                .build();
        AggregatedPage<LogRecord> constantScoreQuery = elasticsearchTemplate.queryForPage(searchQuery5, LogRecord.class);
        System.err.println("constantScoreQuery");
        System.out.println(JSON.toJSONString(constantScoreQuery));

        */
/**
 * 范围查询
 *//*

        SearchQuery searchQuery6 = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.rangeQuery("id")
                        .from(666).includeLower(true)
                        .to(777).includeUpper(true))
                .withPageable(pageable)
                .build();
        AggregatedPage<LogRecord> rangeQuery = elasticsearchTemplate.queryForPage(searchQuery6, LogRecord.class);
        System.err.println("rangeQuery");
        System.out.println(JSON.toJSONString(rangeQuery));

        */
/**
 * 通配符查询
 *//*

        SearchQuery searchQuery7 = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.wildcardQuery("userName", "张*"))
                .withPageable(pageable)
                .build();
        AggregatedPage<LogRecord> wildcardQuery = elasticsearchTemplate.queryForPage(searchQuery7, LogRecord.class);
        System.err.println("wildcardQuery");
        System.out.println(JSON.toJSONString(wildcardQuery));

    }

    */
/**
 * 加载文章数据索引到es
 *//*

    @Test
    public void loadArticleIndex() {
        List<BlogArticle> articleList = blogArticleService.list();
        List<IndexQuery> templateBulkIndex = new ArrayList<>(articleList.size());
        articleList.forEach(article -> {
            IndexQuery indexQuery = new IndexQueryBuilder()
                    .withIndexName("bblog_article")
                    .withType("_doc")
                    .withId(article.getId())
                    .withObject(article)
                    .build();
            templateBulkIndex.add(indexQuery);
        });
        elasticsearchTemplate.bulkIndex(templateBulkIndex);
    }

*/

}
